package com.ls.lserp.modules.setting.service;

import com.ls.lserp.common.service.CrudService;
import com.ls.lserp.common.utils.DateUtils;
import com.ls.lserp.common.utils.ResourcesUtil;
import com.ls.lserp.dbaccess.Dao.StyleFitEntityMapper;
import com.ls.lserp.dbaccess.Entity.StyleFitEntity;
import com.ls.lserp.dbaccess.Entity.StyleQualityControlEntity;
import com.ls.lserp.modules.order.dao.OrderDao;
import com.ls.lserp.modules.order.entity.CustomizationContract;
import com.ls.lserp.modules.order.entity.FitProperty;
import com.ls.lserp.modules.order.entity.Order;
import com.ls.lserp.modules.order.entity.StyleOperationtings;
import com.ls.lserp.modules.order.service.OrderService;
import com.ls.lserp.modules.setting.dao.CheckProjectDao;
import com.ls.lserp.modules.setting.dao.CheckQualityDao;
import com.ls.lserp.modules.setting.entity.CheckProjectEntity;
import com.ls.lserp.modules.setting.entity.CheckQualityEntity;
import com.ls.lserp.modules.setting.entity.OperatingEntity;
import com.ls.lserp.modules.setting.entity.OperatingRREntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
@Transactional(readOnly = false)
public class CheckQualityService extends CrudService<CheckQualityDao,CheckQualityEntity>{
    
    @Autowired
    private CheckQualityDao checkQualityDao ;
    @Autowired
    private StyleFitEntityMapper styleFitEntityMapper;
    
	/**
	 * 获取质检项目
	 * @param checkQualityEntity
	 * @return
	 * @throws Exception 
	 */
    public CheckQualityEntity findQualityItemList(CheckQualityEntity checkQualityEntity){
    	List<OperatingEntity> operatingList = findOperatingList();
    	List<CheckQualityEntity> itemList = findItemList(checkQualityEntity);
    	checkQualityEntity.setQcList(itemList);
    	checkQualityEntity.setOperatingList(operatingList);
    	return checkQualityEntity;
	}
    
    /**
	 * 获取质检项目集
	 * @param checkQualityEntity
	 * @return
	 */
    public List<CheckQualityEntity> findItemList(CheckQualityEntity checkQualityEntity){
    	return checkQualityDao.findQualityItemList(checkQualityEntity);
	}
    
    /**
	 * 获取工序集
	 * @param checkQualityEntity
	 * @return
	 * @throws Exception 
	 */
    public List<OperatingEntity> findOperatingList(){
    	return checkQualityDao.selectValueNameCn ();
	}
    
    /**
	 * 获取所有质检项目
	 * @param checkQualityEntity
	 * @return
	 * @throws Exception 
	 */
   public List<CheckQualityEntity> findAllQualityItem(CheckQualityEntity checkQualityEntity){
   	return checkQualityDao.findAllQualityItem(checkQualityEntity);
	}
    
    /**
	 * 保存质检项目数据
	 * @param checkProjectEntity
	 * @return
	 * @throws Exception 
	 */
    public void insertQcId(CheckQualityEntity checkQualityEntity) throws Exception {
    	System.out.println("质检项目 数据处理 开始------------------------------"+DateUtils.getDate("yyyy-MM-dd HH:mm:ss"));
    	// 需要新增的项目集
    	List<CheckQualityEntity> insertItemList = new ArrayList<>();
    	// 需要删除的项目集
    	List<CheckQualityEntity> deleteItemList = new ArrayList<>();
    	// 查询旧的质检项目集
    	List<CheckQualityEntity> oldItemList = findItemList(checkQualityEntity);
    	// 新的质检项目集
    	List<CheckQualityEntity> newItemList = checkQualityEntity.getQcList ();
    	if (oldItemList != null && oldItemList.size() > 0) {
    		if (newItemList != null && newItemList.size() > 0) {
    			// 获取删除项目集
    			deleteItemList = getResultItemList(oldItemList,newItemList);
    			// 获取新增项目集
    			insertItemList = getResultItemList(newItemList,oldItemList);
    			// 删除项目数据
    			deleteItemData(deleteItemList);
    			// 插入项目数据
    			insertItemData(insertItemList);
    			// 若 新增项目集 或 删除项目集 存在数据，则进行质检关联表数据的删除和插入处理，否则数据不动。
    			//if (insertItemList.size() > 0 || deleteItemList.size() > 0) {
    				// 物理删除质检项目关联表数据
    				deleteOperating (checkQualityEntity);
    				// 插入质检项目关联表数据
    				insertOperating (checkQualityEntity);
				//}
			}else {
				// 只有 删除项目集 存在数据，则只进行数据的删除处理
				// 物理删除质检项目关联表数据
				deleteOperating (checkQualityEntity);
			}
		}else {
			if (newItemList != null && newItemList.size () > 0) {
				// 只有 新增项目集 存在数据，则只进行数据的插入处理
				// 插入质检项目关联表数据
				insertOperating (checkQualityEntity);
			}
		}
    	System.out.println("质检项目 数据处理 结束------------------------------"+DateUtils.getDate("yyyy-MM-dd HH:mm:ss"));
    }
    
    /**
     * 检查 检查项目集 中的项目是否存在于 主项目集 中，若不存在，则放入到 结果集 中。
     * 
     * @param checkItemList 检查项目集
     * @param mainItemList 主项目集
     * @return resultList 结果集
     */
    public List<CheckQualityEntity> getResultItemList(List<CheckQualityEntity> checkItemList,List<CheckQualityEntity> mainItemList){
    	// 结果集 
    	List<CheckQualityEntity> resultList = new ArrayList<>();
    	// 存在区分：存在为true，不存在为false，默认false。
		String flag = "false";
		// 需要检查的项目集
		for(CheckQualityEntity checkTemp : checkItemList){
			// 初始化区分
			flag = "false";
			for(CheckQualityEntity mainTemp : mainItemList){
				// 如果 检查项目id 和 主项目id 相等，说明该 检查项目 存在于 主项目集 当中，
				// 设置存在区分为true，并结束当前for循环。
				if (mainTemp.getQcId().equals(checkTemp.getQcId())) {
					flag = "true";
					break;
				}
			}
			// 如果存在区分为false，说明该 检查项目 为所需项目，放入到 结果项目集 中。
			if ("false".equals(flag)) {
				resultList.add(checkTemp);
			}
		}
		// 返回 结果集
		return resultList;
	}
    
    /**
	 * 删除项目数据
	 * @param itemList
	 */
    public void deleteItemData(List<CheckQualityEntity> itemList){
    	System.out.println("DELETE------删除质检项目~数据处理~开始------"+DateUtils.getDate("yyyy-MM-dd HH:mm:ss"));
    	if (itemList != null && itemList.size() > 0) {
    		int count = 1;
    		for(CheckQualityEntity temp : itemList){
    			checkQualityDao.deleteStyleQualityData(temp);
    			System.out.println(count+++"."+temp.getQcItem()+"质检项目 删除数据 完成-----"+DateUtils.getDate("yyyy-MM-dd HH:mm:ss"));
    		}
		}
    	System.out.println("DELETE------删除质检项目~数据处理~结束------"+DateUtils.getDate("yyyy-MM-dd HH:mm:ss"));
	}
    
    /**
	 * 插入项目数据
	 * @param itemList
	 */
    public void insertItemData(List<CheckQualityEntity> itemList){
    	System.out.println("INSERT------新增质检项目~数据处理~开始------"+DateUtils.getDate("yyyy-MM-dd HH:mm:ss"));
    	if (itemList != null && itemList.size() > 0) {
    		// 初始区分，默认false。
    		String initFlag = "false";
    		// 获取相应订单数据
    		List<StyleQualityControlEntity> orderList = new ArrayList<>();
    		int count = 1;
			for(CheckQualityEntity temp : itemList){
				// 量体项目
				if (checkIsFit(temp)||"QC_ORDER".equals(temp.getQcItemCd())||"QC_MATERIAL_NO".equals(temp.getQcItemCd())) {
					if ("false".equals(initFlag)) {
						// 获取设置好的量体质检基础数据。
						orderList = makeListForFit(temp);
						// 设置 初始区分为true。
						initFlag = "true";
					}else if ("true".equals(initFlag)) {
						for(StyleQualityControlEntity sEntity_Fit : orderList){
							sEntity_Fit.setQcItem(temp.getQcItem());
							sEntity_Fit.setQcItemCd(temp.getQcItemCd());
							sEntity_Fit.setQcItemValue(temp.getQcItemValue());
							// 设置订单号数据
							if ("QC_ORDER".equals(temp.getQcItemCd())) {
								sEntity_Fit.setQcItemRealValue(sEntity_Fit.getOrderNo());
							// 设置面料号数据
							}else if ("QC_MATERIAL_NO".equals(temp.getQcItemCd())) {
								sEntity_Fit.setQcItemRealValue(sEntity_Fit.getFabricNo());
							// 设置量体质检数据
							}else {
								sEntity_Fit.setQcItemRealValue(sEntity_Fit.getHashMap().get(temp.getQcItemCd()));
							}
						}
					}
					if (orderList.size()>0) {
						// 插入 新增 款式质检信息数据
						checkQualityDao.insertStyleQualityData(orderList);
					}
				// 设计项目及其他
				}else {
					List<StyleQualityControlEntity> orderListByThisItem = checkQualityDao.findOrderItemData(temp);
					// 线色
					if ("4THN1,4THN2,4THN3,4THN4".indexOf(temp.getQcItemValue()) != -1) {
						for(StyleQualityControlEntity sEntity_Design : orderListByThisItem){
							if (sEntity_Design.getQcItemRealValue().indexOf("弹力线") != -1) {
								sEntity_Design.setRemarks(sEntity_Design.getQcItemRealValue());
								sEntity_Design.setQcItemRealValue(sEntity_Design.getQcItemRealValue().split("\\(")[1].replace(")", ""));
							}
						}
					}
					// 插入 新增 款式质检信息数据
					checkQualityDao.insertStyleQualityData(orderListByThisItem);
				}
				System.out.println(count+++"."+temp.getQcItem()+"质检项目 新增数据 完成-----"+DateUtils.getDate("yyyy-MM-dd HH:mm:ss"));
			}
		}
    	System.out.println("INSERT------新增质检项目~数据处理~结束------"+DateUtils.getDate("yyyy-MM-dd HH:mm:ss"));
	}
    
    /**
     * 设置量体质检数据集合
     * @param checkQualityEntity
     * @return List<StyleQualityControlEntity>
     */
    public List<StyleQualityControlEntity> makeListForFit(CheckQualityEntity checkQualityEntity){
    	// 获取需要增删质检数据的订单集
    	List<StyleQualityControlEntity> tempList = checkQualityDao.findOrderItemData(new CheckQualityEntity());
		if (tempList != null && tempList.size() > 0) {
			for(StyleQualityControlEntity sEntity : tempList){
				// 根据订单的款式id获取量体信息数据
				StyleFitEntity styleFitEntity = styleFitEntityMapper.getFit(new Long(sEntity.getQcStyleId()));
				if (styleFitEntity != null) {
					Map<String, String> hashMap  = new HashMap<>();
					String[] itemCdArray = styleFitEntity.getItemCd().split(",");
					String[] itemValueArray = styleFitEntity.getItemValue().split(",");
					// 将量体信息的 ‘量体code’ 与对应的 ‘量体实际值’ 组成 ‘键值对’ 存入到 map集合 中。
					for (int i = 0; i < itemCdArray.length; i++) {
						hashMap.put(itemCdArray[i],itemValueArray[i]);
					}
					sEntity.preInsert();
					sEntity.setHashMap(hashMap);
					// 根据 传入值 设置相应数据
					if (checkQualityEntity != null) {
						sEntity.setQcItem(checkQualityEntity.getQcItem());
						sEntity.setQcOperatingId(checkQualityEntity.getOperatingId());
						sEntity.setQcItemCd(checkQualityEntity.getQcItemCd());
						sEntity.setQcItemValue(checkQualityEntity.getQcItemValue());
						// 设置订单号数据
						if ("QC_ORDER".equals(checkQualityEntity.getQcItemCd())) {
							sEntity.setQcItemRealValue(sEntity.getOrderNo());
						// 设置面料号数据
						}else if ("QC_MATERIAL_NO".equals(checkQualityEntity.getQcItemCd())) {
							sEntity.setQcItemRealValue(sEntity.getFabricNo());
						// 设置量体质检数据
						}else {
							sEntity.setQcItemRealValue(sEntity.getHashMap().get(checkQualityEntity.getQcItemCd()));
						}
					}
				}
			}
		}
		// 返回集合
    	return tempList;
	}
    
    /**
	 * 查询该项目是否为量体项目
	 * @param checkQualityEntity
	 */
    public boolean checkIsFit(CheckQualityEntity checkQualityEntity){
    	// 获取量体信息
    	FitProperty fitProperty = checkQualityDao.getFitInfo(checkQualityEntity);
    	if (fitProperty != null) {
    		// 是量体项目，返回true
    		return true;
		}
    	// 不是量体项目，返回false
    	return false;
	}
    
    /**
	 * 插入质检项目关联表数据
	 * @param checkQualityEntity
	 */
    public void insertOperating(CheckQualityEntity checkQualityEntity){
   		checkQualityDao.insertOperating(checkQualityEntity);
	}
    
    /**
	 * 物理删除质检项目关联表数据
	 * @param checkQualityEntity
	 */
    public void deleteOperating(CheckQualityEntity checkQualityEntity){
   		checkQualityDao.deleteOperating(checkQualityEntity);
	}
    
    /**
	 * 逻辑删除标准质检项目数据
	 * @param checkQualityEntity
	 */
    public void deleteItem(CheckQualityEntity checkQualityEntity){
   		checkQualityDao.deleteItem(checkQualityEntity);
	}
   
    /**
	 * 通过code获取项目数据
	 * @param checkQualityEntity
	 * @return
	 */
    public CheckQualityEntity getItemByCd(CheckQualityEntity checkQualityEntity){
  		return checkQualityDao.getItemByCd(checkQualityEntity);
	}
   
   /**
	 * 保存标准质检数据
	 * @param checkQualityEntity
	 * @return
	 * @throws Exception 
	 */
	public void saveData(CheckQualityEntity checkQualityEntity) throws Exception{
		if (checkQualityEntity.getQcId() == null || "".equals(checkQualityEntity.getQcId())) {
			//新建
			checkQualityEntity.preInsert();
			checkQualityDao.insert(checkQualityEntity);
		}else{
			//更新
			checkQualityEntity.preUpdate();
			checkQualityDao.update(checkQualityEntity);
		}
	}
}    